﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Teigha.Core;

namespace Teigha.TD
{
	public class OdResBuf : OdRxObject
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdResBuf(IntPtr cPtr, bool cMemoryOwn) : base(TD_DbPINVOKE.OdResBuf_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdResBuf obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdResBuf()
		{
			this.Dispose();
		}

		public override void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							TD_DbPINVOKE.delete_OdResBuf(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
			base.Dispose();
		}

		public new static OdResBuf cast(OdRxObject pObj)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_cast(OdRxObject.getCPtr(pObj));
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdRxClass desc()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdResBuf_desc(), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxClass isA()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdResBuf_isA(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxObject queryX(OdRxClass protocolClass)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdResBuf_queryX(this.swigCPtr, OdRxClass.getCPtr(protocolClass)), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf createObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_createObject();
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void copyFrom(OdRxObject pRb)
		{
			TD_DbPINVOKE.OdResBuf_copyFrom(this.swigCPtr, OdRxObject.getCPtr(pRb));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool IsEqual(OdResBuf Rb)
		{
			bool result = TD_DbPINVOKE.OdResBuf_IsEqual(this.swigCPtr, OdResBuf.getCPtr(Rb));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool IsNotEqual(OdResBuf Rb)
		{
			bool result = TD_DbPINVOKE.OdResBuf_IsNotEqual(this.swigCPtr, OdResBuf.getCPtr(Rb));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public int restype()
		{
			int result = TD_DbPINVOKE.OdResBuf_restype(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setRestype(int resType)
		{
			TD_DbPINVOKE.OdResBuf_setRestype(this.swigCPtr, resType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdResBuf next()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_next(this.swigCPtr);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdResBuf last()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_last(this.swigCPtr);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdResBuf insert(OdResBuf pRb)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_insert(this.swigCPtr, OdResBuf.getCPtr(pRb));
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdResBuf setNext(OdResBuf pRb)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_setNext(this.swigCPtr, OdResBuf.getCPtr(pRb));
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public string getString()
		{
			string result = TD_DbPINVOKE.OdResBuf_getString(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setString(string sValue)
		{
			TD_DbPINVOKE.OdResBuf_setString(this.swigCPtr, sValue);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool getBool()
		{
			bool result = TD_DbPINVOKE.OdResBuf_getBool(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setBool(bool bValue)
		{
			TD_DbPINVOKE.OdResBuf_setBool(this.swigCPtr, bValue);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public sbyte getInt8()
		{
			sbyte result = TD_DbPINVOKE.OdResBuf_getInt8(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setInt8(sbyte iValue)
		{
			TD_DbPINVOKE.OdResBuf_setInt8(this.swigCPtr, iValue);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public short getInt16()
		{
			short result = TD_DbPINVOKE.OdResBuf_getInt16(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setInt16(short iValue)
		{
			TD_DbPINVOKE.OdResBuf_setInt16(this.swigCPtr, iValue);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public int getInt32()
		{
			int result = TD_DbPINVOKE.OdResBuf_getInt32(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setInt32(int iValue)
		{
			TD_DbPINVOKE.OdResBuf_setInt32(this.swigCPtr, iValue);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public long getInt64()
		{
			long result = TD_DbPINVOKE.OdResBuf_getInt64(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setInt64(long iValue)
		{
			TD_DbPINVOKE.OdResBuf_setInt64(this.swigCPtr, iValue);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double getDouble()
		{
			double result = TD_DbPINVOKE.OdResBuf_getDouble(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDouble(double realValue)
		{
			TD_DbPINVOKE.OdResBuf_setDouble(this.swigCPtr, realValue);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGePoint2d getPoint2d()
		{
			OdGePoint2d result = new OdGePoint2d(TD_DbPINVOKE.OdResBuf_getPoint2d(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setPoint2d(OdGePoint2d gePoint)
		{
			TD_DbPINVOKE.OdResBuf_setPoint2d(this.swigCPtr, OdGePoint2d.getCPtr(gePoint));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGePoint3d getPoint3d()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdResBuf_getPoint3d(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setPoint3d(OdGePoint3d gePoint)
		{
			TD_DbPINVOKE.OdResBuf_setPoint3d(this.swigCPtr, OdGePoint3d.getCPtr(gePoint));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGeVector2d getVector2d()
		{
			OdGeVector2d result = new OdGeVector2d(TD_DbPINVOKE.OdResBuf_getVector2d(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setVector2d(OdGeVector2d geVector)
		{
			TD_DbPINVOKE.OdResBuf_setVector2d(this.swigCPtr, OdGeVector2d.getCPtr(geVector).Handle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGeVector3d getVector3d()
		{
			OdGeVector3d result = new OdGeVector3d(TD_DbPINVOKE.OdResBuf_getVector3d(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setVector3d(OdGeVector3d val)
		{
			TD_DbPINVOKE.OdResBuf_setVector3d(this.swigCPtr, OdGeVector3d.getCPtr(val));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdBinaryData getBinaryChunk()
		{
			OdBinaryData result = new OdBinaryData(TD_DbPINVOKE.OdResBuf_getBinaryChunk(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setBinaryChunk(OdBinaryData bChunk)
		{
			TD_DbPINVOKE.OdResBuf_setBinaryChunk(this.swigCPtr, OdBinaryData.getCPtr(bChunk));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdCmColor getColor()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdResBuf_getColor(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setColor(OdCmColor cmColor)
		{
			TD_DbPINVOKE.OdResBuf_setColor(this.swigCPtr, OdCmColor.getCPtr(cmColor));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdResBuf getResBuf()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_getResBuf(this.swigCPtr);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setResBuf(OdResBuf pResBuf)
		{
			TD_DbPINVOKE.OdResBuf_setResBuf(this.swigCPtr, OdResBuf.getCPtr(pResBuf));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbHandle getHandle()
		{
			OdDbHandle result = new OdDbHandle(TD_DbPINVOKE.OdResBuf_getHandle(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setHandle(OdDbHandle vHandle)
		{
			TD_DbPINVOKE.OdResBuf_setHandle(this.swigCPtr, OdDbHandle.getCPtr(vHandle));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId getEntName()
		{
			OdDbObjectId result = new OdDbObjectId(TD_DbPINVOKE.OdResBuf_getEntName(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setObjectId(OdDbObjectId idObject)
		{
			TD_DbPINVOKE.OdResBuf_setObjectId(this.swigCPtr, OdDbObjectId.getCPtr(idObject));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId getObjectId(OdDbDatabase pDb)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdResBuf_getObjectId(this.swigCPtr, OdDbDatabase.getCPtr(pDb));
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbSelectionSet getPickSet()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_getPickSet(this.swigCPtr);
			OdDbSelectionSet result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setPickSet(OdDbSelectionSet pSSet)
		{
			TD_DbPINVOKE.OdResBuf_setPickSet(this.swigCPtr, OdDbSelectionSet.getCPtr(pSSet));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static OdResBuf newRb(int resType)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_0(resType);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_1();
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, bool resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_2(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, sbyte resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_3(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, byte resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_4(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, short resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_5(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, ushort resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_6(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, int resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_7(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, uint resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_8(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, long resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_9(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, ulong resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_10(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, double resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_11(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, OdGePoint2d resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_12(resType, OdGePoint2d.getCPtr(resVal));
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, OdGePoint3d resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_13(resType, OdGePoint3d.getCPtr(resVal));
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, OdGeVector2d resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_14(resType, OdGeVector2d.getCPtr(resVal).Handle);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, OdGeVector3d resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_15(resType, OdGeVector3d.getCPtr(resVal));
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, string resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_16(resType, resVal);
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, OdCmColor resVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_17(resType, OdCmColor.getCPtr(resVal));
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, OdDbObjectId id)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_18(resType, OdDbObjectId.getCPtr(id));
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, OdDbSelectionSet pSSet)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_19(resType, OdDbSelectionSet.getCPtr(pSSet));
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdResBuf newRb(int resType, OdResBuf pNestedRb)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdResBuf_newRb__SWIG_20(resType, OdResBuf.getCPtr(pNestedRb));
			OdResBuf result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdResBuf)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void setAssertIndexByNewRb(int index)
		{
			TD_DbPINVOKE.OdResBuf_setAssertIndexByNewRb(index);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		private object locker = new object();

		private HandleRef swigCPtr;

		public class Data : IDisposable
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public Data(IntPtr cPtr, bool cMemoryOwn)
			{
				this.swigCMemOwn = cMemoryOwn;
				this.swigCPtr = new HandleRef(this, cPtr);
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			public static HandleRef getCPtr(OdResBuf.Data obj)
			{
				if (obj != null)
				{
					return obj.swigCPtr;
				}
				return new HandleRef(null, IntPtr.Zero);
			}

			~Data()
			{
				this.Dispose();
			}

			public virtual void Dispose()
			{
				if (this.swigCPtr.Handle != IntPtr.Zero)
				{
					if (this.swigCMemOwn)
					{
						lock (this.locker)
						{
							if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
							{
								this.swigCMemOwn = false;
								TD_DbPINVOKE.delete_OdResBuf_Data(this.swigCPtr);
							}
						}
						this.swigCMemOwn = false;
					}
					this.swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}

			public bool Bool
			{
				get
				{
					bool result = TD_DbPINVOKE.OdResBuf_Data_Bool_get(this.swigCPtr);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					TD_DbPINVOKE.OdResBuf_Data_Bool_set(this.swigCPtr, value);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public short Int16
			{
				get
				{
					short result = TD_DbPINVOKE.OdResBuf_Data_Int16_get(this.swigCPtr);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					TD_DbPINVOKE.OdResBuf_Data_Int16_set(this.swigCPtr, value);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public int Int32
			{
				get
				{
					int result = TD_DbPINVOKE.OdResBuf_Data_Int32_get(this.swigCPtr);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					TD_DbPINVOKE.OdResBuf_Data_Int32_set(this.swigCPtr, value);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public long Int64
			{
				get
				{
					long result = TD_DbPINVOKE.OdResBuf_Data_Int64_get(this.swigCPtr);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					TD_DbPINVOKE.OdResBuf_Data_Int64_set(this.swigCPtr, value);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public double Double
			{
				get
				{
					double result = TD_DbPINVOKE.OdResBuf_Data_Double_get(this.swigCPtr);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					TD_DbPINVOKE.OdResBuf_Data_Double_set(this.swigCPtr, value);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public IntPtr Pointer
			{
				get
				{
					IntPtr result = TD_DbPINVOKE.OdResBuf_Data_Pointer_get(this.swigCPtr);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					TD_DbPINVOKE.OdResBuf_Data_Pointer_set(this.swigCPtr, value);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public SWIGTYPE_p_OdUInt8 Bytes
			{
				get
				{
					IntPtr intPtr = TD_DbPINVOKE.OdResBuf_Data_Bytes_get(this.swigCPtr);
					SWIGTYPE_p_OdUInt8 result = (intPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_OdUInt8(intPtr, false);
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
					return result;
				}
				set
				{
					TD_DbPINVOKE.OdResBuf_Data_Bytes_set(this.swigCPtr, SWIGTYPE_p_OdUInt8.getCPtr(value));
					if (TD_DbPINVOKE.SWIGPendingException.Pending)
					{
						throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
					}
				}
			}

			public Data() : this(TD_DbPINVOKE.new_OdResBuf_Data(), true)
			{
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
			}

			private object locker = new object();

			private HandleRef swigCPtr;

			protected bool swigCMemOwn;
		}

		public enum ValueType
		{
			kRtNone = 5000,
			kRtDouble,
			kRtPoint2d,
			kRtInt16,
			kRtAngle,
			kRtString,
			kRtEntName,
			kRtPickSet,
			kRtOrient,
			kRtPoint3d,
			kRtInt32,
			kRtColor,
			kRtVoid = 5014,
			kRtListBeg = 5016,
			kRtListEnd,
			kRtDote,
			kRtNil,
			kRtDXF0,
			kRtT,
			kRtResBuf = 5023,
			kRtBool = 290,
			kRtInt8 = 280,
			kRtVector2d = 5002,
			kRtVector3d = 5009,
			kRtBinaryChunk = 310,
			kRtHandle = 320,
			kRtObjectId = 330,
			kRtSoftPointerId = 330,
			kRtHardPointerId = 340,
			kRtSoftOwnershipId = 350,
			kRtHardOwnershipId = 360,
			kDxfInvalid = -9999,
			kDxfXDictionary = -6,
			kDxfPReactors,
			kDxfOperator,
			kDxfXDataStart,
			kDxfHeaderId,
			kDxfFirstEntId = -2,
			kDxfEnd,
			kDxfStart,
			kDxfText,
			kDxfXRefPath = 1,
			kDxfShapeName,
			kDxfBlockName = 2,
			kDxfAttributeTag = 2,
			kDxfSymbolTableName = 2,
			kDxfMstyleName = 2,
			kDxfSymTableRecName = 2,
			kDxfAttributePrompt,
			kDxfDimStyleName = 3,
			kDxfLinetypeProse = 3,
			kDxfTextFontFile = 3,
			kDxfDescription = 3,
			kDxfDimPostStr = 3,
			kDxfTextBigFontFile,
			kDxfDimAPostStr = 4,
			kDxfCLShapeName = 4,
			kDxfSymTableRecComments = 4,
			kDxfHandle,
			kDxfDimBlk = 5,
			kDxfDimBlk1,
			kDxfLinetypeName = 6,
			kDxfDimBlk2,
			kDxfTextStyleName = 7,
			kDxfLayerName,
			kDxfCLShapeText,
			kDxfXCoord,
			kDxfYCoord = 20,
			kDxfZCoord = 30,
			kDxfElevation = 38,
			kDxfThickness,
			kDxfReal,
			kDxfViewportHeight = 40,
			kDxfTxtSize = 40,
			kDxfTxtStyleXScale,
			kDxfViewWidth = 41,
			kDxfViewportAspect = 41,
			kDxfTxtStylePSize,
			kDxfViewLensLength = 42,
			kDxfViewFrontClip,
			kDxfViewBackClip,
			kDxfShapeXOffset = 44,
			kDxfShapeYOffset,
			kDxfViewHeight = 45,
			kDxfShapeScale,
			kDxfPixelScale,
			kDxfLinetypeScale,
			kDxfDashLength,
			kDxfMlineOffset = 49,
			kDxfLinetypeElement = 49,
			kDxfAngle,
			kDxfViewportSnapAngle = 50,
			kDxfViewportTwist,
			kDxfVisibility = 60,
			kDxfLayerLinetype,
			kDxfColor,
			kDxfHasSubentities = 66,
			kDxfViewportVisibility,
			kDxfViewportActive,
			kDxfViewportNumber,
			kDxfInt16,
			kDxfViewMode,
			kDxfCircleSides,
			kDxfViewportZoom,
			kDxfViewportIcon,
			kDxfViewportSnap,
			kDxfViewportGrid,
			kDxfViewportSnapStyle,
			kDxfViewportSnapPair,
			kDxfRegAppFlags = 71,
			kDxfTxtStyleFlags = 71,
			kDxfLinetypeAlign,
			kDxfLinetypePDC,
			kDxfInt32 = 90,
			kDxfSubclass = 100,
			kDxfEmbeddedObjectStart,
			kDxfControlString,
			kDxfDimVarHandle = 105,
			kDxfUCSOrg = 110,
			kDxfUCSOriX,
			kDxfUCSOriY,
			kDxfXReal = 140,
			kDxfInt64 = 160,
			kDxfXInt16 = 170,
			kDxfNormalX = 210,
			kDxfNormalY = 220,
			kDxfNormalZ = 230,
			kDxfXXInt16 = 270,
			kDxfInt8 = 280,
			kDxfRenderMode,
			kDxfBool = 290,
			kDxfXTextString = 300,
			kDxfBinaryChunk = 310,
			kDxfArbHandle = 320,
			kDxfSoftPointerId = 330,
			kDxfHardPointerId = 340,
			kDxfSoftOwnershipId = 350,
			kDxfHardOwnershipId = 360,
			kDxfLineWeight = 370,
			kDxfPlotStyleNameType = 380,
			kDxfPlotStyleNameId = 390,
			kDxfXXXInt16 = 400,
			kDxfLayoutName = 410,
			kDxfComment = 999,
			kDxfXdAsciiString,
			kDxfRegAppName,
			kDxfXdControlString,
			kDxfXdLayerName,
			kDxfXdBinaryChunk,
			kDxfXdHandle,
			kDxfXdXCoord = 1010,
			kDxfXdYCoord = 1020,
			kDxfXdZCoord = 1030,
			kDxfXdWorldXCoord = 1011,
			kDxfXdWorldYCoord = 1021,
			kDxfXdWorldZCoord = 1031,
			kDxfXdWorldXDisp = 1012,
			kDxfXdWorldYDisp = 1022,
			kDxfXdWorldZDisp = 1032,
			kDxfXdWorldXDir = 1013,
			kDxfXdWorldYDir = 1023,
			kDxfXdWorldZDir = 1033,
			kDxfXdReal = 1040,
			kDxfXdDist,
			kDxfXdScale,
			kDxfXdInteger16 = 1070,
			kDxfXdInteger32
		}
	}
}
